package com.hgkj.cloud.customer.common;

import java.util.HashMap;
import java.util.HashSet;
import java.util.Map;
import java.util.Set;

public class ClsHKEffective {
	// 五个有效性等级说明
	public String[] invalid_reason_s = { "完全不可信", "可能乱答", "答题欠认真", "答题偶有疏忽", "完全可信" };
	public String[] invalid_reason_f = { "胡乱作答，不予出具报告，请重新认真答题。", "答题随意，可能乱答，需重新认真答题后再出具报告。", "没有认真读题，结果真实性存疑。",
			"答题偶有疏忽，不能100%反应真实情况。", "答题认真，结果真实可信。" };

	public class HKBasicsScl90 {
		// 答题总时间控制范围
		int answer_seconds = 121;
		// 最短答题时间
		int time = 1;
		// 最大连续出现一秒数量
		int short_counts = 71;
		// *********************************************************************************************************
		// 答题时间异常分析，目前只有一种大类：x代表某一题的用时answer_time代表每题的答题用时条件参数并以秒为单位；x <
		// answer_time即满足条件，答题时间异常值加一。
		int answer_time = 0;
		// *********************************************************************************************************

		// *********************************************************************************************************
		// 答题不一致性分析，目前有转换为两种大类型，满足以下条件，答题不一致性值加一
		// 大类1：a，b代表题目的选项值，c代表满足条件的参数；{a,b,c}含义为|a-b|>=3，即满足a-b的绝对值大于等于c的情况。
		int[][] answer_uniformity_1 = { { 8, 6, 3 }, { 24, 11, 3 }, { 36, 34, 3 }, { 37, 36, 3 }, { 45, 38, 3 },
				{ 62, 3, 3 }, { 63, 11, 3 }, { 63, 24, 3 }, { 69, 34, 3 }, { 74, 11, 3 }, { 76, 36, 3 } };
		// 大类2：a，c代表题目的选项值，b，d代表满足条件的参数；{a,b,c,d}含义为a>b and c<d，即同时满足a>b和c<d两个条件的情况。
		int[][] answer_uniformity_2 = { { 69, 2, 2, 2 }, { 71, 1, 28, 2 }, { 81, 1, 67, 2 }, { 89, 1, 26, 2 },
				{ 51, 4, 90, 2 } };
		// 大类3：a,b,d,e代表题目的选项值，c,f代表满足条件的参数；{a,b,c,d,e,f}含义为a-b>=c or
		// d-e>=f，即满足a-b>=c或者d-e>=f两个条件中任何一个情况。
		int[][] answer_uniformity_3 = { { 63, 11, 3, 63, 24, 3 } };
		// 大类4：a,b,d,f代表题目的选项值，c,e,g代表满足条件的参数；{a,b,c,d,e,f,g}含义为a-b>=c or (d>e and
		// f<g)，即满足a-b>=c或者(d>e and f<g)两个条件中任何一个情况。
		int[][] answer_uniformity_4 = { { 69, 34, 3, 69, 2, 2, 2 } };
		// *********************************************************************************************************
	}

	// 一百十、中国中学生心理健康检测(Xljk)，共60题
	public class HKBasicsXljk {
		// *********************************************************************************************************
		// 答题时间异常分析，目前只有一种大类：x代表某一题的用时answer_time代表每题的答题用时条件参数并以秒为单位；x <
		// answer_time即满足条件，答题时间异常值加一。
		int answer_time = 0;
		// *********************************************************************************************************

		// *********************************************************************************************************
		// 答题不一致性分析，目前有转换为两种大类型，满足以下条件，答题不一致性值加一
		// 大类1：a，b代表题目的选项值，c代表满足条件的参数；{a,b,c}含义为|a-b|>=3，即满足a-b的绝对值大于等于c的情况。
		int[][] answer_uniformity_1 = { { 15, 6, 3 }, { 56, 46, 3 } };
		// *********************************************************************************************************
	}

	/*
	 * //十二、90项症状清单（Scl90） public class AiBasicsScl90 {
	 * //***************************************************************************
	 * ******************************
	 * //答题时间异常分析，目前只有一种大类：x代表某一题的用时answer_time代表每题的答题用时条件参数并以秒为单位；x <
	 * answer_time即满足条件，答题时间异常值加一。 public int answer_time = 2;
	 * //***************************************************************************
	 * ******************************
	 * 
	 * //***************************************************************************
	 * ****************************** //答题不一致性分析，目前有转换为两种大类型，满足以下条件，答题不一致性值加一
	 * //大类1：a，b代表题目的选项值，c代表满足条件的参数；{a,b,c}含义为|a-b|>=3，即满足a-b的绝对值大于等于c的情况。 public
	 * int[][] answer_uniformity_1 =
	 * {{8,6,3},{24,11,3},{36,34,3},{37,36,3},{45,38,3},
	 * {62,3,3},{69,34,3},{74,11,3},{76,36,3}};
	 * //大类2：a，c代表题目的选项值，b，d代表满足条件的参数；{a,b,c,d}含义为a>b and c<d，即同时满足a>b和c<d两个条件的情况。
	 * public int[][] answer_uniformity_2 =
	 * {{71,1,28,2},{81,1,67,2},{89,1,26,2},{51,4,90,2}};
	 * //大类3：a,b,d,e代表题目的选项值，c,f代表满足条件的参数；{a,b,c,d,e,f}含义为a-b>=c or
	 * d-e>=f，即满足a-b>=c或者d-e>=f两个条件中任何一个情况。 public int[][] answer_uniformity_3 =
	 * {{63,11,3,63,24,3}};
	 * //大类4：a,b,d,f代表题目的选项值，c,e,g代表满足条件的参数；{a,b,c,d,e,f,g}含义为a-b>=c or (d>e and
	 * f<g)，即满足a-b>=c或者(d>e and f<g)两个条件中任何一个情况。 public int[][] answer_uniformity_4
	 * = {{69,34,3,69,2,2,2}};
	 * //***************************************************************************
	 * ****************************** }
	 */

	// 十二、90项症状清单（Scl90）共90题
	public Map<String, Object> GetHKScl90Effective(String answer, String answer_seconds) {
		HKBasicsScl90 basics = new HKBasicsScl90();
		Map<String, Object> map = new HashMap<String, Object>();
		Boolean bl_return = false;

		String[] strAnswer_s = answer.split("\\|");

		try {
			int i;
			// 答题总时间是否小于等于121秒，（秒数可调）
			int answer_second = 0;
			boolean boolsecond = false;
			// 连续出现答题用时为1秒的题数
			int short_count = 0;
			boolean boolshort = false;

			// 答题时间过短的题目总数
			int short_time_count = 0;
			// 关联题目之间逻辑不一致的次数
			int inconsistency_count = 0;
			// 选项同类性分析，目前是判断所有题目选项是否完全相同。目前这个值记录完全相同的选项是什么，即全选1，answer_identical即为1，类推
			String answer_identical = "";
			// 答题可信度评级5-1；5为完全可信，1为完全不可信，其他类推
			int authenticity = 0;

			// 连续出现答题用时为1秒的题数
			for (i = 0; i < answer_seconds.split("\\|").length - 1; i++) {
				answer_second += Integer.valueOf(answer_seconds.split("\\|")[i].toString());
				if (Integer.valueOf(answer_seconds.split("\\|")[i].toString()) == basics.time
						&& Integer.valueOf(answer_seconds.split("\\|")[i + 1].toString()) == basics.time) {
					short_count += 1;
				}
			}
			answer_second += Integer
					.valueOf(answer_seconds.split("\\|")[answer_seconds.split("\\|").length - 1].toString());

			if (short_count >= basics.short_counts) {
				boolshort = true;
			}

			if (answer_second <= basics.answer_seconds) {
				boolsecond = true;
			}

			// 计算答题时间异常总数
			for (i = 0; i < answer_seconds.split("\\|").length; i++) {
				if (Integer.valueOf(answer_seconds.split("\\|")[i].toString()) < basics.answer_time) {
					short_time_count += 1;
				}
			}

			// 答题不一致性分析，目前有转换为两种大类型，满足以下条件，答题不一致性值加一
			// 大类1：a，b代表题目的选项值，c代表满足条件的参数；{a,b,c}含义为|a-b|>=3，即满足a-b的绝对值大于等于c的情况。
			for (i = 0; i < basics.answer_uniformity_1.length; i++) {
				if (Math.abs(Integer.valueOf(strAnswer_s[basics.answer_uniformity_1[i][0] - 1]) - Integer.valueOf(
						strAnswer_s[basics.answer_uniformity_1[i][1] - 1])) >= basics.answer_uniformity_1[i][2]) {
					inconsistency_count += 1;
				}
			}
			// 大类2：a，c代表题目的选项值，b，d代表满足条件的参数；{a,b,c,d}含义为a>b and c<d，即同时满足a>b和c<d两个条件的情况。
			for (i = 0; i < basics.answer_uniformity_2.length; i++) {
				if (Integer
						.valueOf(strAnswer_s[basics.answer_uniformity_2[i][0] - 1]) > basics.answer_uniformity_2[i][1]
						&& Integer.valueOf(
								strAnswer_s[basics.answer_uniformity_2[i][2] - 1]) < basics.answer_uniformity_2[i][3]) {
					inconsistency_count += 1;
				}
			}

			// 判断所有答题选项是否完全相同
			Set<String> hs_set = new HashSet<String>();
			for (i = 0; i < answer.split("\\|").length; i++) {
				String str = answer.split("\\|")[i];
				String value = "";
				if (i == 14) {
					switch (str) {
					case "1":
						value = "没有";
						break;
					case "2":
						value = "很轻";
						break;
					case "3":
						value = "中等";
						break;
					case "4":
						value = "偏重";
						break;
					case "5":
						value = "严重";
						break;
					}
					map.put("fifteenth", value);
				}
				hs_set.add(str);
			}

			if (hs_set.size() == 1) // 长度为1，代表全部相同
			{
				// 因为上面判断长度为1，所以下面只会循环一次，直接把内容赋值给参数即可
				for (String string : hs_set) {
					answer_identical = string;
				}
			} else {
				answer_identical = "选项未出现完全相同";
			}

			// 判断答题可信度等级
			// 答题疑点“极多”
			if (answer_identical.equals("5") || answer_identical.equals("4") || answer_identical.equals("3")
					|| answer_identical.equals("2") || (answer_identical.equals("1") && short_time_count >= 5)
					|| short_time_count >= 6 || inconsistency_count >= 10 || boolshort == true || boolsecond == true) {
				authenticity = 1;
				bl_return = true;
			}
			// 答题疑点“多”
			if (bl_return == false) {
				if (short_time_count == 5 || inconsistency_count == 9) {
					authenticity = 2;
					bl_return = true;
				}
			}
			// 答题疑点“中”
			if (bl_return == false) {
				if ((short_time_count >= 3 && short_time_count <= 4)
						|| (inconsistency_count >= 4 && inconsistency_count <= 8)) {
					authenticity = 3;
					bl_return = true;
				}
			}
			// 答题疑点“少”
			if (bl_return == false) {
				if ((short_time_count >= 1 && short_time_count <= 2)
						|| (inconsistency_count >= 1 && inconsistency_count <= 3)) {
					authenticity = 4;
					bl_return = true;
				}
			}
			// 答题疑点极“无”
			if (bl_return == false) {
				authenticity = 5;
				bl_return = true;
			}

			String reStr = invalid_reason_s[authenticity - 1];
			map.put("reliability", reStr);
			return map;
		} catch (ArithmeticException e) {

			return map;
		}
	}
}
